home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / javax / swing / BufferStrategyPaintManager.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  9.7 KB  |  469 lines
  1. package javax.swing;
  2.  
  3. import java.applet.Applet;
  4. import java.awt.Container;
  5. import java.awt.Graphics;
  6. import java.awt.Rectangle;
  7. import java.awt.Window;
  8. import java.awt.image.BufferStrategy;
  9. import java.lang.reflect.Method;
  10. import java.security.AccessController;
  11. import java.util.ArrayList;
  12. import java.util.List;
  13. import java.util.logging.Level;
  14. import java.util.logging.Logger;
  15. import sun.awt.SubRegionShowable;
  16. import sun.java2d.SunGraphics2D;
  17. import sun.security.action.GetPropertyAction;
  18.  
  19. class BufferStrategyPaintManager extends RepaintManager.PaintManager {
  20.    private static Method COMPONENT_CREATE_BUFFER_STRATEGY_METHOD;
  21.    private static Method COMPONENT_GET_BUFFER_STRATEGY_METHOD;
  22.    private static boolean TRY_FLIP = "true".equals(AccessController.doPrivileged(new GetPropertyAction("swing.useFlipBufferStrategy", "false")));
  23.    private static final Logger LOGGER = Logger.getLogger("javax.swing.BufferStrategyPaintManager");
  24.    private ArrayList<BufferInfo> bufferInfos = new ArrayList(1);
  25.    private boolean painting;
  26.    private boolean showing;
  27.    private int accumulatedX;
  28.    private int accumulatedY;
  29.    private int accumulatedMaxX;
  30.    private int accumulatedMaxY;
  31.    private JComponent rootJ;
  32.    private Container root;
  33.    private int xOffset;
  34.    private int yOffset;
  35.    private Graphics bsg;
  36.    private BufferStrategy bufferStrategy;
  37.    private BufferInfo bufferInfo;
  38.    private boolean disposeBufferOnEnd;
  39.  
  40.    private static Method getGetBufferStrategyMethod() {
  41.       if (COMPONENT_GET_BUFFER_STRATEGY_METHOD == null) {
  42.          getMethods();
  43.       }
  44.  
  45.       return COMPONENT_GET_BUFFER_STRATEGY_METHOD;
  46.    }
  47.  
  48.    private static Method getCreateBufferStrategyMethod() {
  49.       if (COMPONENT_CREATE_BUFFER_STRATEGY_METHOD == null) {
  50.          getMethods();
  51.       }
  52.  
  53.       return COMPONENT_CREATE_BUFFER_STRATEGY_METHOD;
  54.    }
  55.  
  56.    private static void getMethods() {
  57.       AccessController.doPrivileged(new 1());
  58.    }
  59.  
  60.    protected void dispose() {
  61.       SwingUtilities.invokeLater(new 2(this));
  62.    }
  63.  
  64.    private void dispose(List<BufferInfo> var1) {
  65.       if (LOGGER.isLoggable(Level.FINER)) {
  66.          LOGGER.log(Level.FINER, "BufferStrategyPaintManager disposed", new RuntimeException());
  67.       }
  68.  
  69.       if (var1 != null) {
  70.          for(BufferInfo var3 : var1) {
  71.             var3.dispose();
  72.          }
  73.       }
  74.  
  75.    }
  76.  
  77.    public boolean show(Container var1, int var2, int var3, int var4, int var5) {
  78.       synchronized(this) {
  79.          if (this.painting) {
  80.             return false;
  81.          }
  82.  
  83.          this.showing = true;
  84.       }
  85.  
  86.       boolean var10;
  87.       try {
  88.          BufferInfo var6 = this.getBufferInfo(var1);
  89.          BufferStrategy var7;
  90.          if (var6 == null || javax.swing.BufferStrategyPaintManager.BufferInfo.access$500(var6) || !var6.isInSync() || (var7 = var6.getBufferStrategy(false)) == null) {
  91.             return false;
  92.          }
  93.  
  94.          SubRegionShowable var8 = (SubRegionShowable)var7;
  95.          boolean var9 = var6.getPaintAllOnExpose();
  96.          var6.setPaintAllOnExpose(false);
  97.          if (!var8.validateAndShow(var2, var3, var2 + var4, var3 + var5)) {
  98.             this.bufferInfo.setContentsLostDuringExpose(true);
  99.             return false;
  100.          }
  101.  
  102.          var10 = !var9;
  103.       } finally {
  104.          synchronized(this) {
  105.             this.showing = false;
  106.             this.notifyAll();
  107.          }
  108.       }
  109.  
  110.       return var10;
  111.    }
  112.  
  113.    public boolean paint(JComponent var1, JComponent var2, Graphics var3, int var4, int var5, int var6, int var7) {
  114.       if (this.prepare(var1, true, var4, var5, var6, var7)) {
  115.          if (var3 instanceof SunGraphics2D && ((SunGraphics2D)var3).getDestination() == this.root) {
  116.             int var8 = ((SunGraphics2D)this.bsg).constrainX;
  117.             int var9 = ((SunGraphics2D)this.bsg).constrainY;
  118.             if (var8 != 0 || var9 != 0) {
  119.                this.bsg.translate(-var8, -var9);
  120.             }
  121.  
  122.             ((SunGraphics2D)this.bsg).constrain(this.xOffset + var8, this.yOffset + var9, var4 + var6, var5 + var7);
  123.             this.bsg.setClip(var4, var5, var6, var7);
  124.             var1.paintToOffscreen(this.bsg, var4, var5, var6, var7, var4 + var6, var5 + var7);
  125.             this.accumulate(this.xOffset + var4, this.yOffset + var5, var6, var7);
  126.             return true;
  127.          }
  128.  
  129.          this.bufferInfo.setInSync(false);
  130.       }
  131.  
  132.       if (LOGGER.isLoggable(Level.FINER)) {
  133.          LOGGER.finer("prepare failed");
  134.       }
  135.  
  136.       return super.paint(var1, var2, var3, var4, var5, var6, var7);
  137.    }
  138.  
  139.    public void copyArea(JComponent var1, Graphics var2, int var3, int var4, int var5, int var6, int var7, int var8, boolean var9) {
  140.       if (this.prepare(var1, false, 0, 0, 0, 0) && this.bufferInfo.isInSync()) {
  141.          if (var9) {
  142.             Rectangle var10 = var1.getVisibleRect();
  143.             int var11 = this.xOffset + var3;
  144.             int var12 = this.yOffset + var4;
  145.             this.bsg.clipRect(this.xOffset + var10.x, this.yOffset + var10.y, var10.width, var10.height);
  146.             this.bsg.copyArea(var11, var12, var5, var6, var7, var8);
  147.          } else {
  148.             this.bsg.copyArea(this.xOffset + var3, this.yOffset + var4, var5, var6, var7, var8);
  149.          }
  150.  
  151.          this.accumulate(var3 + this.xOffset + var7, var4 + this.yOffset + var8, var5, var6);
  152.       } else {
  153.          if (LOGGER.isLoggable(Level.FINER)) {
  154.             LOGGER.finer("copyArea: prepare failed or not in sync");
  155.          }
  156.  
  157.          if (!this.flushAccumulatedRegion()) {
  158.             this.rootJ.repaint();
  159.          } else {
  160.             super.copyArea(var1, var2, var3, var4, var5, var6, var7, var8, var9);
  161.          }
  162.       }
  163.  
  164.    }
  165.  
  166.    public void beginPaint() {
  167.       synchronized(this) {
  168.          this.painting = true;
  169.  
  170.          while(this.showing) {
  171.             try {
  172.                this.wait();
  173.             } catch (InterruptedException var4) {
  174.             }
  175.          }
  176.       }
  177.  
  178.       if (LOGGER.isLoggable(Level.FINEST)) {
  179.          LOGGER.finest("beginPaint");
  180.       }
  181.  
  182.       this.resetAccumulated();
  183.    }
  184.  
  185.    public void endPaint() {
  186.       if (LOGGER.isLoggable(Level.FINEST)) {
  187.          LOGGER.finest("endPaint: region " + this.accumulatedX + " " + this.accumulatedY + " " + this.accumulatedMaxX + " " + this.accumulatedMaxY);
  188.       }
  189.  
  190.       if (this.painting && !this.flushAccumulatedRegion()) {
  191.          if (!this.isRepaintingRoot()) {
  192.             this.repaintRoot(this.rootJ);
  193.          } else {
  194.             this.resetDoubleBufferPerWindow();
  195.             this.rootJ.repaint();
  196.          }
  197.       }
  198.  
  199.       BufferInfo var1 = null;
  200.       synchronized(this) {
  201.          this.painting = false;
  202.          if (this.disposeBufferOnEnd) {
  203.             this.disposeBufferOnEnd = false;
  204.             var1 = this.bufferInfo;
  205.             this.bufferInfos.remove(var1);
  206.          }
  207.       }
  208.  
  209.       if (var1 != null) {
  210.          var1.dispose();
  211.       }
  212.  
  213.    }
  214.  
  215.    private boolean flushAccumulatedRegion() {
  216.       boolean var1 = true;
  217.       if (this.accumulatedX != Integer.MAX_VALUE) {
  218.          SubRegionShowable var2 = (SubRegionShowable)this.bufferStrategy;
  219.          boolean var3 = this.bufferStrategy.contentsLost();
  220.          if (!var3) {
  221.             var2.show(this.accumulatedX, this.accumulatedY, this.accumulatedMaxX, this.accumulatedMaxY);
  222.             var3 = this.bufferStrategy.contentsLost();
  223.          }
  224.  
  225.          if (var3) {
  226.             if (LOGGER.isLoggable(Level.FINER)) {
  227.                LOGGER.finer("endPaint: contents lost");
  228.             }
  229.  
  230.             this.bufferInfo.setInSync(false);
  231.             var1 = false;
  232.          }
  233.       }
  234.  
  235.       this.resetAccumulated();
  236.       return var1;
  237.    }
  238.  
  239.    private void resetAccumulated() {
  240.       this.accumulatedX = Integer.MAX_VALUE;
  241.       this.accumulatedY = Integer.MAX_VALUE;
  242.       this.accumulatedMaxX = 0;
  243.       this.accumulatedMaxY = 0;
  244.    }
  245.  
  246.    public void doubleBufferingChanged(JRootPane var1) {
  247.       if ((!var1.isDoubleBuffered() || !var1.getUseTrueDoubleBuffering()) && var1.getParent() != null) {
  248.          if (!SwingUtilities.isEventDispatchThread()) {
  249.             3 var2 = new 3(this, var1);
  250.             SwingUtilities.invokeLater(var2);
  251.          } else {
  252.             this.doubleBufferingChanged0(var1);
  253.          }
  254.       }
  255.  
  256.    }
  257.  
  258.    private void doubleBufferingChanged0(JRootPane var1) {
  259.       BufferInfo var2;
  260.       synchronized(this) {
  261.          while(this.showing) {
  262.             try {
  263.                this.wait();
  264.             } catch (InterruptedException var6) {
  265.             }
  266.          }
  267.  
  268.          var2 = this.getBufferInfo(var1.getParent());
  269.          if (this.painting && this.bufferInfo == var2) {
  270.             this.disposeBufferOnEnd = true;
  271.             var2 = null;
  272.          } else if (var2 != null) {
  273.             this.bufferInfos.remove(var2);
  274.          }
  275.       }
  276.  
  277.       if (var2 != null) {
  278.          var2.dispose();
  279.       }
  280.  
  281.    }
  282.  
  283.    private boolean prepare(JComponent var1, boolean var2, int var3, int var4, int var5, int var6) {
  284.       if (this.bsg != null) {
  285.          this.bsg.dispose();
  286.          this.bsg = null;
  287.       }
  288.  
  289.       this.bufferStrategy = null;
  290.       if (this.fetchRoot(var1)) {
  291.          boolean var7 = false;
  292.          BufferInfo var8 = this.getBufferInfo(this.root);
  293.          if (var8 == null) {
  294.             var7 = true;
  295.             var8 = new BufferInfo(this, this.root);
  296.             this.bufferInfos.add(var8);
  297.             if (LOGGER.isLoggable(Level.FINER)) {
  298.                LOGGER.finer("prepare: new BufferInfo: " + this.root);
  299.             }
  300.          }
  301.  
  302.          this.bufferInfo = var8;
  303.          if (!var8.hasBufferStrategyChanged()) {
  304.             this.bufferStrategy = var8.getBufferStrategy(true);
  305.             if (this.bufferStrategy == null) {
  306.                return false;
  307.             }
  308.  
  309.             this.bsg = this.bufferStrategy.getDrawGraphics();
  310.             if (this.bufferStrategy.contentsRestored()) {
  311.                var7 = true;
  312.                if (LOGGER.isLoggable(Level.FINER)) {
  313.                   LOGGER.finer("prepare: contents restored in prepare");
  314.                }
  315.             }
  316.  
  317.             if (var8.getContentsLostDuringExpose()) {
  318.                var7 = true;
  319.                var8.setContentsLostDuringExpose(false);
  320.                if (LOGGER.isLoggable(Level.FINER)) {
  321.                   LOGGER.finer("prepare: contents lost on expose");
  322.                }
  323.             }
  324.  
  325.             if (var2 && var1 == this.rootJ && var3 == 0 && var4 == 0 && var1.getWidth() == var5 && var1.getHeight() == var6) {
  326.                var8.setInSync(true);
  327.             } else if (var7) {
  328.                var8.setInSync(false);
  329.                if (!this.isRepaintingRoot()) {
  330.                   this.repaintRoot(this.rootJ);
  331.                } else {
  332.                   this.resetDoubleBufferPerWindow();
  333.                }
  334.             }
  335.  
  336.             return this.bufferInfos != null;
  337.          }
  338.       }
  339.  
  340.       return false;
  341.    }
  342.  
  343.    private boolean fetchRoot(JComponent var1) {
  344.       boolean var2 = false;
  345.       this.rootJ = var1;
  346.       this.root = var1;
  347.       this.xOffset = this.yOffset = 0;
  348.  
  349.       while(this.root != null && !(this.root instanceof Window) && !(this.root instanceof Applet)) {
  350.          this.xOffset += this.root.getX();
  351.          this.yOffset += this.root.getY();
  352.          this.root = this.root.getParent();
  353.          if (this.root != null) {
  354.             if (this.root instanceof JComponent) {
  355.                this.rootJ = (JComponent)this.root;
  356.             } else if (!this.root.isLightweight()) {
  357.                if (var2) {
  358.                   return false;
  359.                }
  360.  
  361.                var2 = true;
  362.             }
  363.          }
  364.       }
  365.  
  366.       return this.root instanceof RootPaneContainer && this.rootJ instanceof JRootPane && this.rootJ.isDoubleBuffered() && ((JRootPane)this.rootJ).getUseTrueDoubleBuffering();
  367.    }
  368.  
  369.    private void resetDoubleBufferPerWindow() {
  370.       if (this.bufferInfos != null) {
  371.          this.dispose(this.bufferInfos);
  372.          this.bufferInfos = null;
  373.          this.repaintManager.setPaintManager((RepaintManager.PaintManager)null);
  374.       }
  375.  
  376.    }
  377.  
  378.    private BufferInfo getBufferInfo(Container var1) {
  379.       for(int var2 = this.bufferInfos.size() - 1; var2 >= 0; --var2) {
  380.          BufferInfo var3 = (BufferInfo)this.bufferInfos.get(var2);
  381.          Container var4 = var3.getRoot();
  382.          if (var4 == null) {
  383.             this.bufferInfos.remove(var2);
  384.             if (LOGGER.isLoggable(Level.FINER)) {
  385.                LOGGER.finer("BufferInfo pruned, root null");
  386.             }
  387.          } else if (var4 == var1) {
  388.             return var3;
  389.          }
  390.       }
  391.  
  392.       return null;
  393.    }
  394.  
  395.    private void accumulate(int var1, int var2, int var3, int var4) {
  396.       this.accumulatedX = Math.min(var1, this.accumulatedX);
  397.       this.accumulatedY = Math.min(var2, this.accumulatedY);
  398.       this.accumulatedMaxX = Math.max(this.accumulatedMaxX, var1 + var3);
  399.       this.accumulatedMaxY = Math.max(this.accumulatedMaxY, var2 + var4);
  400.    }
  401.  
  402.    // $FF: synthetic method
  403.    static Method access$002(Method var0) {
  404.       COMPONENT_CREATE_BUFFER_STRATEGY_METHOD = var0;
  405.       return var0;
  406.    }
  407.  
  408.    // $FF: synthetic method
  409.    static Method access$000() {
  410.       return COMPONENT_CREATE_BUFFER_STRATEGY_METHOD;
  411.    }
  412.  
  413.    // $FF: synthetic method
  414.    static Method access$102(Method var0) {
  415.       COMPONENT_GET_BUFFER_STRATEGY_METHOD = var0;
  416.       return var0;
  417.    }
  418.  
  419.    // $FF: synthetic method
  420.    static Method access$100() {
  421.       return COMPONENT_GET_BUFFER_STRATEGY_METHOD;
  422.    }
  423.  
  424.    // $FF: synthetic method
  425.    static boolean access$200(BufferStrategyPaintManager var0) {
  426.       return var0.showing;
  427.    }
  428.  
  429.    // $FF: synthetic method
  430.    static ArrayList access$300(BufferStrategyPaintManager var0) {
  431.       return var0.bufferInfos;
  432.    }
  433.  
  434.    // $FF: synthetic method
  435.    static ArrayList access$302(BufferStrategyPaintManager var0, ArrayList var1) {
  436.       return var0.bufferInfos = var1;
  437.    }
  438.  
  439.    // $FF: synthetic method
  440.    static void access$400(BufferStrategyPaintManager var0, List var1) {
  441.       var0.dispose(var1);
  442.    }
  443.  
  444.    // $FF: synthetic method
  445.    static void access$600(BufferStrategyPaintManager var0, JRootPane var1) {
  446.       var0.doubleBufferingChanged0(var1);
  447.    }
  448.  
  449.    // $FF: synthetic method
  450.    static Logger access$700() {
  451.       return LOGGER;
  452.    }
  453.  
  454.    // $FF: synthetic method
  455.    static Method access$800() {
  456.       return getGetBufferStrategyMethod();
  457.    }
  458.  
  459.    // $FF: synthetic method
  460.    static boolean access$900() {
  461.       return TRY_FLIP;
  462.    }
  463.  
  464.    // $FF: synthetic method
  465.    static Method access$1000() {
  466.       return getCreateBufferStrategyMethod();
  467.    }
  468. }
  469.